Functional Baby Talk: Analysis of Code Fragments from Novice Haskell Programmers

What kinds of mistakes are made by novice Haskell developers, as they learn about functional programming? Is it possible to analyze these errors in order to improve the pedagogy of Haskell? In 2016, we delivered a massive open online course which featured an interactive code evaluation environment. We captured and analyzed 161K interactions from learners. We report typical novice developer behavior; for instance, the mean time spent on an interactive tutorial is around eight minutes. Although our environment was restricted, we gain some understanding of Haskell novice errors. Parenthesis mismatches, lexical scoping errors and do block misunderstandings are common. Finally, we make recommendations about how such beginner code evaluation environments might be enhanced

Evaluating Lossy Collections for Java Applications

We propose to remove live objects from near-full heaps to reduce memory pressure. We modify Java Collections to enable lossy behavior. Some DaCapo benchmarks tolerate an amount of live data loss

Programming Language Feature Agglomeration

Feature-creep is a well-known phenomenon in software systems. In this paper, we argue that feature-creep also occurs in the domain of programming languages. Recent languages are more expressive than earlier languages. However recent languages generally extend rather than replace the syntax (sometimes) and semantics (almost always) of earlier languages. We demonstrate this trend of agglomeration in a sequence of languages comprising Pascal, C, Java, and Scala. These are all block-structured Algol-derived languages, with earlier languages providing explicit inspiration for later ones. We present empirical evidence from several language-specific sources, including grammar definitions and canonical manuals. The evidence suggests that there is a trend of increasing complexity in modern languages that have evolved from earlier languages

Does Disaggregrated Compute Require a New Programming Paradigm?

No abstract available

The utility of the anxiety cluster scale of the Piers-Harris children\u27s self-concept scale to identify anxiety problems in 10 year old children

It is widely accepted in the literature that internalised childhood psychopathology including anx1cty is best identified by child self-report, followed by observations by parents and then to a lesser extent, by teachers. Although anxiety scales are a useful way to quantify anxiety symptomatology and progress through treatment, changes to classification systems (e.g., DSM-111-R to DSM-IV) make their ability to screen for the presence of psychiatric problems difficult. This research looked at whether the Anxiety Cluster (AC) scale of the Piers-Harris Children\u27s Self-Concept Scale (PHCSCS) can be used to identify anxiety disorders in children. Two separate studies were conducted in the present research. Study 1 sought to compare AC scores from 160 ten year old Western Australian school children to normative information provided in the PHCSCS manual. Study 2 involved administering the Anxiety Disorders Interview Schedule for DSM IV: Child Version (AD!S-C) to a sample of 76 children drawn from Study I to compare AC scores to anxiety diagnosis. The 76 participants comprised all II children with AC scores between 0 and 5 (indicating anxiety), all 47 children with AC scores between 6 and 9 (considered a-typical) and a sample of 18 out of 100 children with AC scores between 10 and 14 (indicating no anxiety). Sampling of the 10 to 14 group was necessary due to resource limitations for this study. Results for Study I found that AC scores for this cohort were approximately I point higher (indicating less anxiety) than reported in the manual. This result was unlikely to be due to inadequate sampling, rather, that the normative information for the PHCSCS does not provide for age and sex differences. Results for Study 2 were that I 0 out of II subjects (91%) with AC scores between 0 and 5 met sufficient criteria for one or more anxiety disorder, whilst 17 out of 18 children (94%) with AC scores between I 0 and 14 did not. Although it would increase the number false positives, raising the clinical cut-off to an AC score of 7 is recommended as it would reduce the number of false negatives. It would appear therefore, that the AC scale has good utility for use as a first stage screening tool. As such, an application could be the selection of children for intervention groups who are likely to have an anxiety disorder (AC score 0 to 7) and as a reasonable means of precluding those children who are unlikely to have an anxiety disorder (AC score l 0 to 14). A second stage screening involving a structured diagnostic interview would be necessary for the remaining children (i.e., AC score 8 and 9). Limitations of this study are discussed in terms of inter-rater reliability of diagnostic interviews and the sampling of approximately l in 5 children with AC scores of 10- 14 due to resource constraints

Peer-to-Peer Secure Updates for Heterogeneous Edge Devices

We consider the problem of securely distributing software updates to large scale clusters of heterogeneous edge compute nodes. Such nodes are needed to support the Internet of Things and low-latency edge compute scenarios, but are difficult to manage and update because they exist at the edge of the network behind NATs and firewalls that limit connectivity, or because they are mobile and have intermittent network access. We present a prototype secure update architecture for these devices that uses the combination of peer-to-peer protocols and automated NAT traversal techniques. This demonstrates that edge devices can be managed in an environment subject to partial or intermittent network connectivity, where there is not necessarily direct access from a management node to the devices being updated

Financial access for immigrants: the challenges and opportunities facing U.S. depository institutions

Immigrants

ALPyNA: Acceleration of Loops in Python for Novel Architectures

We present ALPyNA, an automatic loop parallelization framework for Python, which analyzes data dependences within nested loops and dynamically generates CUDA kernels for GPU execution. The ALPyNA system applies classical dependence analysis techniques to discover and exploit potential parallelism. The skeletal structure of the dependence graph is determined statically (if possible) or at runtime; this is combined with type and bounds information discovered at runtime, to auto-generate high-performance kernels for offload to GPU. We demonstrate speedups of up to 1000x relative to the native CPython interpreter across four array-intensive numerical Python benchmarks. Performance improvement is related to both iteration domain size and dependence graph complexity. Nevertheless, this approach promises to bring the benefits of manycore parallelism to application developers